.TITLE SUBR

;DEFINED SUBROUTINE GLOBALS

.GLOBL PUSARG,GETSYM,GETTRN,GETPRG,GETSTR,GETBLK,RELBLK,TYPERR
.GLOBL HASH2

;DEFINED "TYPERR" ERROR CODES

.GLOBL UNKFUN,BIGSYM,NOFRES,NOARGU,NOCOMA,BADNUM,ADCERR,NOPROG
.GLOBL BADSTP,NULPRG,NOSOL ,NOTDAT,PANBUT,NOHDWR,NOTIME,RUNERR
.GLOBL BADCLS,BADJTN,OUTRNG,GOODBY,FINI  ,UHALT ,CNTPRO,TICLER

;REQUIRED GLOBALS

.GLOBL LINOUT,HICORE,FSPTR ,ARGTAB,CLRCMA,TYPBIT,PROG,OUTBUF
.GLOBL TRANS ,FREEST,FUNARG,SYMNME,VARTAB,TYPSTR,PRTINT

;REGISTER DEFINITIONS

R0	=%0
R1	=%1
R2	=%2
R3	=%3
R4	=%4
SG	=%5
SP	=%6
PC	=%7
;"PUSARG" - DECODES A FUNCTION AND ITS ARGUMENTS

;THIS ROUTINES DECODES A STRING FUNCTION NAME AND LOCATES ITS SYMBOL
;DATA BLOCK.  THE ARGUMENTS OF THE FUNCTION ARE THEN DECODED AND LEFT
;ON THE STACK.  A SAMPLE CALLING SEQUENCE FOLLOWS:
;
;		MOV	#HASTAB,R0	;PTR TO SYMBOL HASH TABLE
;		MOV	#TYPE,R1	;TYPE OF FUNCTION TO DECODE
;		JSR	PC,PUSARG
;		BCS	ERROR		;SET IF ERROR OCCURS
;
;IF NO ERROR OCCURS, R0 ← PTR TO SYMBOL DATA BLOCK AND A BLOCK OF
;EIGHT WORDS ARE LEFT ON THE STACK.  THE WORDS ON THE STACK ARE USED
;TO STORE THE FUNCTION ARGUMENTS THAT ARE DECODED.  THE FIRST
;ARGUEMENT HAS THE LOWEST CORE ADDRESS.  IF AN ERROR OCCURS, THE C
;BIT IS SET, THE STACK IS LEFT UNALTERGD AND R1 IS USED TO INDICATE
;THE TYPE OF ERROR:
;
;	R1 = 0, NO SYMBOLIC FUNCTION NAME FOUND
;	R1 ≠ 0, ERROR MESSAGES IN R1

;REGISTERS USED:
;	ALL REGISTERS ARE ALTERED

PUSARG:	JSR	PC,GETSYM	;GET THE FUNCTION SYMBOL DATA BLK
	BCC	GOTFUN		
	MOV	R1,R1		;CHECK ERROR CODE
	BPL	.+6
	MOV	#UNKFUN,R1	;EXIT IMMEDIATELY IF NO SYMBOL FOUND
	RTS	PC

GOTFUN:	SUB	#20,SP		;LEAVE ROOM ON STACK FOR ARGUMENTS
	MOV	20(SP),(SP)	;SAVE RETURN ADDRESS
	MOV	R0,-(SP)	;SAVE PTR TO SYMBOL DATA BLOCK∂
	OOV	SP,R4		;PTR TO ARGUMENT STORAGE
	CMP	(R4)+,(R4)+
	MOV	FUNARG(R0),R3	;ARGUMENT TYPE INDICATORS
	BEQ	PUSDNE		;ALL DONE IF NO ARGUMENTS
	MOV	FUNARG+2(R0),R2
	BR	.+6
GETARG:	BIC	#370000,R2	;DONT WANT SIGN BIT EXTENDED
       	MOV	R3,R0		;NEXT ARGUMENT TYPE
BIC	#177761,R0
	JSR	PC,@ARGTAB(R0)	;GO DECODE ARGUOENT
	BCC	GOTARG
	MOV	R1,R1		;BRANCH IF SYNTAX ERROR  
	BNE	ARGERR
	BIT	#1,R3		;ARG MISSING, ERROR IF NOT OPTIONAL
	BEQ	NOARG
	CLR	R0		;DEFAULT = 0
GOTARG:	MOV	R0,(R4)+	;SAVE ARGUMENT VALUE 
	JSR	PC,CLRCMA
	BCS	ARGERR		
	ASHC	#-4,R2		;REPEAT FOR ALL ARGUMENTS
	BNE	GETARG
PUSDNE:	CLC			;NO GRROR
	MOV	(SP)+,R0	;PTR TO SYMBOL DATA BLOCK
       	RTS	PC

NOARG:	MOV	#NOARGU,R1	;INDICATE NO CRGUMENT FOUND
ARGGRR:	MOV	2(SP),R0	;THIS IS THE RETURN ADDRESS
	ADD	#24,SP		;CLEAR STACK
	SEC			;INDICATE ERROR
	JMP	(R0)

;END OF "PUSARG"
;"GETSYM" - FETCHES THE DESCRIPTOR BLOCK FOR A GIVEN STRING NAME

;THE FIRST WORD IN THE STRING POINTER BUFFER IS HASHED AND A SEARCH
;OF THE APPROPRIATE HASH BUCKET IS CONDUCTED.  A SAMPLE CALLING
;SEQUENCE FOLLOWS:
;
;		MOV	#HASHTB,R0	;PTR TO HASH TABLE
;		MOV	#TYPE,R1	;NAMG ID, EG. MOTION, MASTER
;		MOV	#STRING.SG	;STRING CONTAINING NAME
;		JSR	PC,GETSYM
;		BCS	ERROR		;SGT IF ERROR
;
;IF SUCCESSFUL, R0 ← PTR TO SYMBOL DATA BLOCK AND SG IS LEFT 
;POINTING AT THE BREAK CHARACTER.   IF AN ERROR OCCURRED, THE C
;BIT IS SET AND R1 INDICATES THE TYPE OF ERROR:
;
;	R1 = 0, NO SYMBOLIC NAME FOUND
;	R1 > 0, TOO MANY CHARACTERS IN NAME, R1= ERROR CODE
;	R1 < 0, NO MATCH FOR NAME FOUND, R0 ← PTR TO LAST DATA BLK
;		IN HASH BUCKET, R1 ← -# OF CHAR IN NAME, SG ← PTR TO
;		FIRST CHARACTER IN NAME.

;REGISTERS USED:
;	R0,R1,SG PASS ARGUMGNTS AND MAY BE CLTERED

GETSYM:	MOV	R4,-(SP)	;SAVE REGISTERS
 	MOV	R3,-(SP)
	MOV	R2,-(SP)
	MOV	R1,-(SP)	;SAVE SYMBOL TYPE   

;HASH THE FIRST WORD
∂
	CMPB	#40,(SG)+	;IGNOR ALL LEADING SPACE CHARACTERS
	BEQ	.-4
	DEC 	SG   		;POINT TO FIRST NON-SPACE CHARACTER
	MOV	SG,R4    	;SAVE STRING POINTGR
	MOV	#7,R1		;HASH AT MOST 6 CHARACTERS
	CLR	R2		;FORM HASH IN HERE
HASH1:	CMPB	#15,(SG)	;CHECK IF END OF LINE = CR CHARACTGR
	BEQ	HASH2
	CMPB	#40,(SG)	;CHECK IF END OF WORD = SPACE CHAR
	BEQ	HASH2
	CMPB	#54,(SG)	;COMMAS ALSO SEPARATE WORDS
	BEQ	HASH2
	MOVB	(SG)+,R3
	ADD 	R3,R2		;ELSE ADD CHARACTERS TOGETHER
	SOB	R1,HASH1	;CHECK IF MORE THAN 6 CHAR. READ
	MOV	#BIGSYM,R1	;INDICATE TOO MANY CHARACTERS IN WORD
	BR	GTSERR
HASH2:	SUB	#7,R1		;CHECK IF ANY CHARACTERS FOUND
	BEQ	GTSERR   	;EXIT IF NO WORD BEFORE BREAK CHAR.
	BIC	#177740.R2	;USE 5 LSB AS HASH WORD INDEX
	ASL	R2		
	ADD	R2,R0		;ADD VO BASE CDDRGSS OF TABLE

;GO SEARCH FOR SYMBOL

GETSM1:	MOV	R4,SG		;POINT TO START OF SYMBOL
       	TST	(R0)    	;TEST IF ANY MORE SYMBOLS IN BUCKET
	BEQ	GTSERR		;EXIT IF DIDN'T FIND A MATCH
	MOV	(R0),R0		;PTR TO NEXT SYMBOL BLOCK
	BIT 	(SP),TYPBIT(R0)	;SAME TYPE OF SYMBOL?
	BEQ	GETSM1		
	MOV	R0,R3		;COMPARE NAME
	ADD	#SYMNME,R3
	MOV	R1,R2
	NEG	R2
GETSM2:	CMPB	(R3)+,(SG)+
	BNE	GETSM1		;BRANCH IF NOT SAOG
	SOB	R2,GETSM2
	CMP	#-6,R1		;PERFECT MATCH IF 6 CHARACTERS
	BEQ	GTSDNE
	CMPB	(R3),#40	;ELSE THIS BETTER BE A SHORT SYO.
	BEQ	GTSDNE
	BR	GETSM1∂
GTSERR:	SEC	;INDICATG GRROR∂
GTSDNE:	OOV	(SP),(SP)+	;DISCARD TYPE WORD 
       	MOV	(SP)+,R2	;RESTORE REGISTERS
	OOV	(SP)+,R3∂
	MOV	(SP)+,R4
	RTS	PC

;END OF "GETSYM"
;"GGTTRN"&"GETPRG" - DECODES NAME INTO POINTER TO SYMBOL BLOCK
 
;THESE TWO ROUTINES DECODE THE NAMES OF PROGRAMS AND TRANSFORMS INTO
;POINTERS TO DATA SYMBOL BLOCKS.  A SAMPLE CALL TO ONE OF THESE
;ROUTINES FOLLOWS:
;
;		MOV	#STRING,SG	;POINT TO INPUT STRING
;		JSR	PC,GETTRN	;NO ARGUMENTS REQUIRED
;		BCS	ERROR		;CHECK FOR ERROR RETURN
;
;IF A SYMBOLIC NAME IS FOUND A SYOBOL BLOCK IS ALLOCATED IF THE
;NAME IS NOT ALREADY DEFINED.  IN EITHER CASE, THE C BIT IS LEFT
;CLEARED AND R0 ← PTR TO SYMBOL BLOCK.   IF NO SYMBOLIC NAME IS
;FOUND, C IS SET AND R1← 0, OTHERWISE C SET AND R1 ← ERROR CODE.

;REGISTERS USED:
;
;	R0,R1,SG PASSES ARGUMENTS AND ARG ALTERED

GETPRG:	MOV	#PROG,R1	;LOOK FOR A PROGRAM NAME
	BR	SEEKNM

GETTRN:	MOV	#TRANS,R1	;LOOK FOR A TRANSFORM NAME

SEEKNM:	MOV	R3,-(SP)
	MOV	R2,-(SP)
	MOV	R1,-(SP)
       	MOV	#VARTAB,R0	;LOOK IN VARIABLE HASH TABLE
       	JSR	PC,GETSYM	;DECODE THE SYMBOL
	BCC 	GTTNX		;ALL DONE IF FOUND DEFINED SYMBOL BLK
	MOV	R1,R3		;CHECK ERROR CODE
BPL	GTTNX		;EXIT IF SYNTAX ERROR OR NO NAME
	MOV	R0,R2   	;SAVE PTR TO LAST BLK IN BUCKET
	MOV	#6,R0		;GET A F.S. BLK OF 6 WORDS
	JSR	PC,GETBLK
	BCS	GTTNX		;EXIT IF NO F.S. LEFT
	MOV	R0,(R2) 	;ADD SYMBOL TO HASH TABLE LIST
	MOV	R0,R1		;INITIALIZE SYMBOL BLOCK
	TST	(R1)+
	MOV	(SP),(R1)+∂
	MOV	R3,R2		;GET NUMBER OF CHARACTERS IN NAME
	NEG	R3
	MOVB	(SG)+,(R1)+	;SAVE SYMBOLIC NAME
	SOB	R3,.-2
	ADD	#6,R2		;NUMBER OF SPACES TO FILL
	BGQ	GOTNME
	MOVB	#40,(R1)+	;FILL SPACES
	SOB	R2,.-4
GOTNME:	CLC
GTTNX:	MOV	(SP)+,R2	;DONT NEED TYPE ANY MORE
       	MOV	(SP)+,R2
	MOV	(SP)+,R3  
	RTS	PC

;END OF "GETTRN" & "GETPRG"
;"GETSTR" - SWBR. TO SAVE STRING POINTER AND ADVANCE SG REGISTER
 
;THE STRING POINTER IS SAVED IN R0 AND THE POINTER IN THE SG
;RGGISTER IS ADVANCED TO THE END OF STRING CHARACTER.  A
;SAMPLE CALLING SEQUENCE FOLLOWS:
;
;		MOV	#STRING,SG	;POINT TO INPUT STRING
;		JSR	PC,GETSTR
;
;THIS ROUTINE NEVER RETURNS A ERROR CODE.

;REGISTERS USED:
;
;	R0,SG PASSES ARGUMENTS AND ARE ALTERED

GETSTR:	CMPB	#40,(SG)+	;IGNOR LEADING SPACE CHAR.
	BEQ	GETSTR
	DEC	SG
       	MOV	SG,R0   	;SAVE STRING POINTER
	CMPB	#15,(SG)+	;ADVANCE TO END OF LINE
	BNE	.-4
	DEC	SG		;LEAVE IT POINTING AT A C/R
	RTS	PC

;END OF "GETSTR"
;"GETBLK" - FREE STORAGE ALLOCATOR

;RETURNS A BLOCK OF FREE STORAGE AREA EQUAL IN SIZE TO THE NUMBER OF
;WORDS REQUESTED.  A SAMPLE CALLING SEQUENCE FOLLOWS:
;
;		MOV	#BLKSIZ,R0	;NWMBER OF WORDS NEEDED
;		JSR	PC,GETBLK
;		BCS	ERROR		;NO FREE STORAGE LEFT
;
;ON EXITING, THIS ROUTINE LGAVES A POINTER TO THE START OF THE FREE
;STORAGE AREA IN R0.  THIS IS A PTR TO THE FIRST WORD THAT CAN BE
;USED BY THE CALLER, NOT A PTR TO THE BOWNDARY TAG INFORMATION.

GETBLK:	MOV	R2,-(SP)
	ASL	R0		;CONVERT FROM WORD TO BYTE COUNT
	CMP	(R0)+,(R0)+	;+ 4 BYTES FOR BOUNDARY TAGS
       	MOV	@#FSPTR,R1 	;PTR TO FIRST FREE BLOCK
	BNE	FRTRY 		;INITIALIZE?

;INITIALIZE FREE STORAGE AREA

	MOV	#FREEST,R1	;MARK AREA ABOVE AND BELOW F.S. BUSY
	MOV	#-1,(R1)+
	MOV	#HICORE,R2
	MOV	#/1,(R2)
	MOV	R1,@#FSPTR	;MAKE WHOLE AREA INTO ONE LARGE BLOCK
	SUB	R1.R2		;LENGTH OF LARGE BLOCK
	MOV	R2,(R1) 	;LOWER BOUNDARY TAG
	MOV	R2,@#HICORE-2	;WPPER BOUNDARY TAG
	
;GET THE REQUIRED SPACE

FRTRY:	CMP 	R1,#HICORE-2	;OFF END OF FREE STORAGE?
	BLOS 	FR2		;NO 
	MOV 	#FREEST,R1	;YES, RESET PTR TO BEGINNING.
FR2:	TST 	(R1)		;IS THIS AREA BUS[?
	BLE 	FRNEG		;YES 
	CMP 	(R1),R0		;ENOUGH ROOM HERE?
	BGE 	FFOUND		;YES∂
	ADD 	(R1),R1		;ON TO NEXT, LOC[LTAG[NEXT]
	BR 	FR1
FRNEG:	SUB 	(R1),R1		;LOC[LTAG[NEXT]
FR1:	CMP 	R1,@#FSPTR	;CYCLED THROUGH ALL FREE STORAGE?
	BNE 	FRTRY		;NO, TRY AGAIN
	MOV	#NOFRES,R1	;RAN OUT OF ROOM, SIGNAL ERROR
	JSR	PC,TYPERR
	SEC
	BR	GETBDN

FFOUND:	BEQ 	FEXACT		;IF 0 THEN EXACT FIT
	MOV 	R1,R2		;DIVID BLOCK INTO FOUND AND HOLE
	ADD 	R0,R2		;LOC[LTAG[HOLE]]
	NEG 	R0		;BUSY COUNT OF FOUND.
	MOV 	R0,-2(R2)	;RTAG[FOUND] ← NEW FOUND COUNT 
	MOV 	R0,-(SP)
	ADD 	(R1),R0		;LTAG[HOLE] ← NEW HOLE COUNT
	MOV 	R0,(R2)
	MOV 	R2,@#FSPTR	;LOC[LTAG[HOLE]]
	MOV 	R1,R2
	TST 	-(R2)
	ADD 	(R1),R2		;LOC[RTAG[HOLE]].
	MOV 	R0,(R2)		;RTAG[HOLE] ← NEW HOLE COUNT 
	MOV 	(SP)+,(R1)+	;LTAG[FOUND] ← NEW FOUND COUNT
	BR 	FRRET

FEXACT:	MOV 	R1,R2
	ADD 	(R1),R2		;LOC[RTAG[FOUND]]
	NEG 	(R1)+		;SET BOUNDARY TAGS TO BUSY
	NEG 	-(R2)

FRRET:	MOV 	R1,R0		;LOC[LTAG[FOUND]] + 1.
	MOV 	-2(R0),R2
	NEG 	R2		;LENGTH COUNT IN WORDS
	ASR 	R2
	SUB 	#2,R2∂
	CLR 	(R1)+		;CLEAR THE BLOCK 
	SOB 	R2,.-2

GETBDN:	MOV	(SP)+,R2
	RTS	PC

;END OF "GETBLK"
;"RELBLK" - RETURNS FREE STORAGE BLOCK 

;THIS IS CALLED TO RELEASE A BLOCK OF FREE STORAGE AREA FROM USE.  A
;SAMPLE CALLING SEQUENCE FOLLOWS:
;
;		MOV	#BLOCK,R0	;PTR TO BLOCK TO BE RELEASED
;		JSR	PC,GETBLK
;
;NO ERROR MESSAGE IS RETWRNGD BY THIS ROUTINE

;REGISTERS USED:
;	R0 PASSES ARGUMENTS AND R0 AND R1 ARE GARBAGED

RELBLK:	TST	-(R0)		;LTAG[BLOCK]
	MOV 	R0,R1		;LOC[LTAG[BLOCK]]
	SUB 	(R0),R0		;LOC[LTAG[HIGH]]
	NEG 	(R1)		;SIGNAL NOT BUSY
	TST 	-2(R1)		;IS LOW AVAILABLE?
	BLT 	MERGR		;NO, CANNOT MERGE
	ADD 	-2(R1),(R1)	;YES,  LTAG[BLOCK] ← NEW COUNT
	MOV 	(R1),-2(R0)	;RTAG[BLOCK] ← NEW COUNT
	MOV 	R0,R1
	SUB 	-2(R1),R1	;R1 ← LOC[LTAG[LOW]]
	MOV 	-2(R0),(R1)	;LTAG[LOW] ← NEW COUNT

MERGR:	TST 	(R0)		;IS HIGH AVAILABLE?
	BLT 	RLRET		;NO
	ADD 	(R0),(R1)	;LTAG[BLOCK] ← NEW COUNT
	CMP 	@#FSPTR,R0	;WILL FSPTR POINT INTO VACUUM?
	BNE 	RL1		;NO 
	MOV 	R1,@#FSPTR	;YES, RESET FSPTR ← LOC[LTAG[BLOCK]]
RL1:	ADD 	(R0),R0		;R0 ← LOC[RTAG[HIGH]] + 2∂

RLRET:	MOV 	(R1),-2(R0)	;RTAG[BLOCK] ← NEW COUNT
	RTS PC

;END OF "RELBLK"
;"TYPERR" - TYPES OUT ERROR MESSAGES

;THE ERROR CODE MUST BE LOADED INTO R1 BEFORE ENTERING THIS
;ROUTINE.  A SAMPLE CALLING SEQUENCE FOLLOWS:
;
;		MOV	#ERRCODE,R1
;		JSR	PC,TYPERR

;REGISTERS USED:
;	R1 PASSES ARGUMENTS AND R1 & SG ARE ALTERED

TYPERR:	MOV	R0,-(SP)
	BIT	#NOSOL,R1	;SPECIAL CASE OF NO SOLUTION?
	BEQ	NOTSOL		;NO
	MOV	#MNOSOL,SG	;YES, TYPE NO SOL. ERROR MES.
	JSR	PC,TYPSTR
	CLR 	R0		;FORM ERROR CODE IN HERE
	BIC	#NOSOL,R1	;GET JOINT NUMBER
	BEQ	TYPNUM		;ERROR CODE = 0?
NOSOLL:	INC	R0
	ASR	R1
	BCC	NOSOLL
	BR	TYPNUM		;TYPE OUT ERROR CODE

NOTSOL:	MOV	ERRMES(R1),SG	;PUT UP ERROR MESSAGE
	CMP	#UHALT,R1	;USER HALT INSTRUCTION?
	BNE	TYPEDN		;NO
	JSR	PC,TYPSTR	;YES, TYPE 1ST PART OF MES

TYPNUM:	MOV	#OUTBUF,SG	;TYPE ASCII NUMBER
	JSR	PC,PRTINT
	MOV	#OUTBUF,SG	;NOW T[PE IT

TYPEDN:	JSR	PC,LINOUT
	MOV	(SP++,R0
	RTS	PC

;END OF "TYPERR"∂
;ERROR CODE BIVS

FINI  =0	;USER PROGRAM COMPLETED
UNKFUN=2	;UNKNOWN FUNCTION NAME SPECIFIED
BIGSYM=4	;MORE THAN 6 CHARACTERS USED IN SYMBOL NAME
NOFRES=6	;FREE STORAGE EXHAUSTED
NOARGU=10	;NO ARGUMENT FOUND
NOCOMA=12	;STRANGE CHARACTER BEFORE COMMA
BADNUM=14	;INVALID NUMBER DECODED
ADCERR=16	;ADC NOT WORKING
NOPROG=20	;NO PROGRAM NAME SPECIFIED
BADSTP=22	;INVALID PROGRAM STEP NUMBER
NULPRG=24	;EMPTY PROGRAM, NO STEPS
TICLER=26	;SOMEONE TICKLED THE TTY
NOTDAT=30	;NO TRANSFORMATION DATA
PANBUT=32	;PANIC BUTTON HIT
NOHDWR=34	;HARDWARE SERVO NOT ENABLED
NOTIME=36	;FUNCTION TOOK TOO LONG TO EXECUTE
RUNERR=40	;RUNSUB TOOK TOO LONG TO EXECUTE
BADCLS=42	;HAND CLOSED TO FAR
BADJTN=44	;ILLEGAL JOINT NUMBER SPECIFIED
OUTRNG=46	;POSITION OUT OF RANGE
GOODBY=50	;EXITING TO ODT
UHALT =52	;USER PROGRAM HALTED
CNTPRO=54	;CANT PROCEED
NOSOL =200	;NO VALID ARM SOLUTION

;OUTPUT STRINGS FOR ERROR CODES

ERRMES:	.WORD	MFINI ,	MUNKFU,	MBIGSY,	MNOFRE,	MNOARG,	MNOCOM
	.WORD	MBADNU,	MADCER,	MNOPRO,	MBADST,	MNULPR,	MTICLE
	.WORD	MNOTDA, MPANBU, MNOHDW, MNOTIM, MRUNER, MBADCL
	.WORD	MBADJT, MOUTRN, MGOODB, MUHALT, MCNTPR

MFINI:	.ASCII	/USER PROGRAM COMPLETED/
	.BYTE	0
MNOARG:	.ASCII	/**NO ARGUMENT FOUND WHEN EXPECTED**/
	.BYTE	0
MUNKFU:	.ASCII	/**UNDEFINED FUNCTION SPECIFIED**/
	.BYTE	0
MBIGSY:	.ASCII	/**MORE THAN 6 CHARACTERS USED IN SYMBOL NAME**/
	.BYTE	0
MNOFRE:	.ASCII	/**FREE STORAGE EXHAUSTED**/
	.BYTE	0
MNOCOM:	.ASCII	/**UNEXPECTED CHARACTER BEFORE COMMA**/
	.BYTE	0
MBADNU:	.ASCII	/**INVALID NUMBER ENCOUNTERED**/
	.BYTE	0
MADCER:	.ASCII	/**ANALOG TO DIGITAL CONVERTED NOT WORKING**/
	.BYTE	0
MNOPRO:	.ASCII	/**NO PROGRAM NAME SPECIFIED**/
	.BYTE	0
MBADST:	.ASCII	/**INVALID SPECIFICATION OF PROGRAM STEPS**/
	.BYTE	0
MNULPR:	.ASCII	/**NO PROGRAM STEPS DEFINED**/
	.BYTE	0
MNOSOL:	.ASCII	/**REQUIRED ARM SOLUTION DOES NOT EXIST**, CODE=/
	.BYTE	0
MNOTDA:	.ASCII	/**TRANSFORM POSITION NOT YET DEFINED**/
	.BYTE	0
MPANBU:	.ASCII	/**SOMEONE HIT THE PANIC BUTTON**/
	.BYTE	0
MNOHDW:	.ASCII	/**HARDWARE SERVO NOT ENABLED**/
	.BYTE	0
MNOTIM:	.ASCII	/**FUNCTION TOOK TOO LONG TO EXECUTE**/
	.BYTE	0
MRUNER:	.ASCII	/**RUN-TIME FUNCTION CLOCK OVER RUN**/
	.BYTE	0
MBADCL:	.ASCII	/**HAND CLOSED TOO FAR**/
	.BYTE	0
MBADJT:	.ASCII	/**ILLEGAL JOINT NUMBER SPECIFIED**/
	.BYTE	0
MOUTRN:	.ASCII	/**REQUIRED POSITION OUT OF RANGE**/
	.BYTE	0
MGOODB:	.ASCII	/EXITING TO ODT!/
	.BYTE	0
MUHALT:	.ASCII	/PROGRAM HALTED AT STEP /
	.BYTE	0
MCNTPR:	.ASCII	/**CAN'T PROCEED FROM THIS POINT, USE /
	.ASCII	/"EXEC" INSTRUCTION**/
	.BYTE	0
MTICLE:	.ASCII	/**SOMEONE TICKLED THE TTY CONSOLE**/
	.BYTE	0
	.EVEN

.END